// hdu5473
// 题意：给定平面上n(<=100)个点，取k个点使得这k个点组成的凸包面积最大。
//
// 题解：首先对所有点求一个凸包，要取的k个点肯定在凸包上，可以枚举起始点
//       （为了能够进行dp），然后dp[i][j]表示取了前i个点，用了j个点，最后
//       一次取i的最大面积，转移O(n)，整个复杂度为O(n^3 * k)，这样复杂度不够，
//       注意到对于最后的k个构成最大面积的点，任意取一个做为起始点就行，
//       故我们随机化n/k个不同的起始点来做dp，这样复杂度到了O(n^3)
//
// 统计：1248ms
//
// run: $exec < bfdiff.in
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <ctime>

template <class T>
struct point
{
	point(T x, T y) : x(x), y(y) {};
	point() {}

	T x, y;
};

template <class T>
bool operator<(point<T> const & a, point<T> const & b)
{
	return a.y < b.y || (a.y == b.y && a.x < b.x);
}

template <class T>
std::istream & operator>>(std::istream & is, point<T> & p)
{
	is >> p.x >> p.y;
	return is;
}


int const maxn = 110;
int vis[maxn];
long long f[maxn][maxn];

std::vector<point<int>> points(maxn);
std::vector<point<int>> stack(2 * maxn);
int n, k, tick;

template <class T>
int signum(T const & x)
{
	return (x < 0 ? -1 : x > 0 ? +1 : 0);
}

template <class T>
int ccw(point<T> const & a, point<T> const & b, point<T> const & c)
{
	return signum((long long)(b.x - a.x) * (c.y - a.y) - (long long)(b.y - a.y) * (c.x - a.x));
}

template <class T>
T myabs(T x) { return x >= 0 ? x : -x; }

template <class T>
long long calc(point<T> const & a, point<T> const & b, point<T> const & c)
{
	long long x1 = b.x - a.x, y1 = b.y - a.y;
	long long x2 = c.x - a.x, y2 = c.y - a.y;
	return myabs(x1 * y2 - x2 * y1);
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::srand(std::time(0));
	int T; std::cin >> T;
	for (int ti = 1; ti <= T; ti++) {
		std::cout << "Case #" << ti << ": ";
		tick++;
		std::cin >> n >> k;
		for (int i = 0; i < n; i++)
			std::cin >> points[i];

		// level convex hull
		std::sort(points.begin(), points.begin() + n);

		int top = 0;
		for (int i = 0; i < n; i++) {
			while (top >= 2 && ccw(stack[top - 2], stack[top - 1], points[i]) < 0)
				top--;
			stack[top++] = points[i];
		}
		int t = top + 1;
		for (int i = n - 2; i >= 0; i--) {
			while (top >= t && ccw(stack[top - 2], stack[top - 1], points[i]) < 0)
				top--;
			stack[top++] = points[i];
		}
		top--;

		if (top < 3) { std::cout << "0\n"; continue; }
		//dp
		long long ans = 0; int all = 0;
		k = std::min(k, top);
		for (int ti = 0, start; all < top && ti < 10 * (top/k); ti++) {
			std::memset(f, 0, sizeof(f));
			start = rand() % top;
			while (vis[start] == tick) start = rand() % top;
			vis[start] = tick; all++;
			for (int i = 2; i < top; i++) {
				for (int j = 3; j <= std::min(k, i + 1); j++) {
					for (int t = 1; t < i; t++) {
						long long ts = calc(stack[start], stack[(start + t) % top], stack[(start + i) % top]);
						f[i][j] = std::max(f[i][j], f[t][j - 1] + ts);
						ans = std::max(ans, f[i][j]);
					}
				}
			}
		}
		std::cout << ans << '\n';
	}
}

